// pages/tenant-info/index.js
Page({
  data: {
    // 表单数据
    name: '', // 姓名
    phone: '', // 联系电话
    startDate: '', // 起租日期
    selectedRoomId: '', // 选中的房间ID
    selectedRoom: null, // 选中的房间信息
    monthlyRent: '', // 每月房租
    paymentMethod: '', // 收款方式
    deposit: '', // 押金
    endDate: '', // 退租时间（可选）

    // 下拉选项
    roomList: [], // 房间列表（从云函数获取）
    roomOptions: [], // 房间选项（用于picker显示）
    selectedRoomIndex: -1, // 选中的房间索引
    paymentMethodOptions: ['月付', '季付', '半年付', '年付'],

    // 选择器显示状态
    showRoomPicker: false,
    showPaymentMethodPicker: false,
    loading: false, // 加载状态
    
    // 合同相关
    contractId: '', // 合同ID
    contractNo: '', // 合同编号
    contractData: null // 合同数据
  },

  async onLoad(options) {
    console.log('承租人信息页面加载完成');
    // 记录流程类型：tenant（租客流程）或 landlord（房东流程）
    const flow = options.flow || 'landlord';
    this.setData({ flow: flow });
    
    // 如果是租客流程，通过合同ID加载合同数据
    if (flow === 'tenant' && options.contractId) {
      this.setData({
        contractId: options.contractId,
        contractNo: options.contractNo || ''
      });
      await this.loadContractData();
    } else {
      // 房东流程，加载房间列表和房东信息
      this.loadRoomList();
      this.loadLandlordInfo();
    }
  },
  
  // 加载合同数据（租客流程）
  async loadContractData() {
    this.setData({ loading: true });
    try {
      const res = await wx.cloud.callFunction({
        name: 'contract',
        data: {
          apiType: 'getContractInfo',
          contractId: this.data.contractId
        }
      });

      if (res.result.res.code === 200) {
        const contractData = res.result.res.data;
        this.setData({ contractData: contractData });
        
        // 预填充表单数据
        this.setData({
          name: contractData.tenantName || '',
          phone: contractData.tenantPhone || '',
          monthlyRent: contractData.monthlyRent || '',
          paymentMethod: contractData.paymentMethod || '',
          deposit: contractData.deposit || '',
          selectedRoomId: contractData.roomId || '',
          // 日期处理
          startDate: contractData.startYear && contractData.startMonth && contractData.startDay 
            ? `${contractData.startYear}-${contractData.startMonth.padStart(2, '0')}-${contractData.startDay.padStart(2, '0')}`
            : '',
          endDate: contractData.endYear && contractData.endMonth && contractData.endDay
            ? `${contractData.endYear}-${contractData.endMonth.padStart(2, '0')}-${contractData.endDay.padStart(2, '0')}`
            : ''
        });
        
        // 加载房间信息（如果合同中有房间ID）
        if (contractData.roomId) {
          await this.loadRoomInfo(contractData.roomId);
        }
        
        // 加载房东信息（从合同数据中获取）
        this.setData({
          landlordInfo: {
            name: contractData.landlordName || '未填写',
            phone: contractData.landlordPhone || '未填写',
            idCard: contractData.landlordIdCard || '未填写',
            address: contractData.landlordAddress || '未填写'
          }
        });
        
        this.setData({ loading: false });
      } else {
        wx.showToast({
          title: res.result.res.msg || '加载合同失败',
          icon: 'none'
        });
        this.setData({ loading: false });
        setTimeout(() => {
          wx.navigateBack();
        }, 1500);
      }
    } catch (error) {
      console.error('加载合同数据失败:', error);
      wx.showToast({
        title: '加载失败，请重试',
        icon: 'none'
      });
      this.setData({ loading: false });
    }
  },
  
  // 加载房间信息（通过房间ID）
  async loadRoomInfo(roomId) {
    try {
      // 注意：租客可能没有权限直接查询房间，这里可以从合同数据中获取房间信息
      // 或者通过云函数查询
      if (this.data.contractData) {
        const contractData = this.data.contractData;
        this.setData({
          selectedRoom: {
            _id: roomId,
            room: contractData.room || '',
            area: contractData.area || '',
            roomType: contractData.roomType || '',
            propertyFee: contractData.propertyFee || ''
          }
        });
      }
    } catch (error) {
      console.error('加载房间信息失败:', error);
    }
  },

  // 加载房东（甲方）信息
  async loadLandlordInfo() {
    try {
      const res = await wx.cloud.callFunction({
        name: 'user',
        data: {
          apiType: 'getUserInfo'
        }
      });

      if (res.result.res.code === 200) {
        const landlordInfo = res.result.res.data;
        this.setData({
          landlordInfo: {
            name: landlordInfo.name || '未填写',
            phone: landlordInfo.phone || '未填写',
            idCard: landlordInfo.idCard || '未填写',
            address: landlordInfo.address || '未填写'
          }
        });
      } else {
        // 如果用户不存在，使用默认值
        this.setData({
          landlordInfo: {
            name: '未填写',
            phone: '未填写',
            idCard: '未填写',
            address: '未填写'
          }
        });
      }
    } catch (error) {
      console.error('加载房东信息失败:', error);
      // 出错时使用默认值
      this.setData({
        landlordInfo: {
          name: '未填写',
          phone: '未填写',
          idCard: '未填写',
          address: '未填写'
        }
      });
    }
  },

  // 加载房间列表（只加载可用房间）
  async loadRoomList() {
    this.setData({ loading: true });
    try {
      const res = await wx.cloud.callFunction({
        name: 'room',
        data: {
          apiType: 'getAvailableRoomList'
        }
      });

      if (res.result.res.code === 200) {
        const roomList = res.result.res.data || [];
        const roomOptions = roomList.map(room => {
          return room.room || `房间${room._id.substring(0, 8)}`;
        });

        this.setData({
          roomList: roomList,
          roomOptions: roomOptions,
          loading: false
        });
      } else {
        wx.showToast({
          title: res.result.res.msg || '加载房间列表失败',
          icon: 'none'
        });
        this.setData({ loading: false });
      }
    } catch (error) {
      console.error('加载房间列表失败:', error);
      wx.showToast({
        title: '加载房间列表失败',
        icon: 'none'
      });
      this.setData({ loading: false });
    }
  },

  // 姓名输入
  onNameInput(e) {
    this.setData({
      name: e.detail.value
    });
  },

  // 联系电话输入
  onPhoneInput(e) {
    this.setData({
      phone: e.detail.value
    });
  },

  // 起租日期选择
  onStartDateChange(e) {
    this.setData({
      startDate: e.detail.value
    });
  },

  // 房间选择
  onRoomChange(e) {
    const selectedIndex = parseInt(e.detail.value);
    const selectedRoom = this.data.roomList[selectedIndex];
    
    if (selectedRoom) {
      this.setData({
        selectedRoomId: selectedRoom._id,
        selectedRoom: selectedRoom,
        selectedRoomIndex: selectedIndex
      });
    }
  },

  // 每月房租输入
  onMonthlyRentInput(e) {
    this.setData({
      monthlyRent: e.detail.value
    });
  },

  // 收款方式选择
  onPaymentMethodChange(e) {
    this.setData({
      paymentMethod: this.data.paymentMethodOptions[e.detail.value]
    });
  },

  // 押金输入
  onDepositInput(e) {
    this.setData({
      deposit: e.detail.value
    });
  },


  // 退租时间选择
  onEndDateChange(e) {
    this.setData({
      endDate: e.detail.value
    });
  },

  // 表单验证
  validateForm() {
    const { phone, selectedRoomId, monthlyRent, paymentMethod, deposit, startDate } = this.data;
    
    // 如果填写了手机号，则验证格式
    if (phone && phone.trim() !== '') {
      const phoneReg = /^1[3-9]\d{9}$/;
      if (!phoneReg.test(phone)) {
        wx.showToast({
          title: '请输入正确的手机号',
          icon: 'none'
        });
        return false;
      }
    }

    if (!selectedRoomId) {
      wx.showToast({
        title: '请选择房间',
        icon: 'none'
      });
      return false;
    }

    if (!monthlyRent || monthlyRent.trim() === '') {
      wx.showToast({
        title: '请输入每月房租',
        icon: 'none'
      });
      return false;
    }

    if (!paymentMethod) {
      wx.showToast({
        title: '请选择收款方式',
        icon: 'none'
      });
      return false;
    }

    if (!deposit || deposit.trim() === '') {
      wx.showToast({
        title: '请输入押金',
        icon: 'none'
      });
      return false;
    }

    if (!startDate || startDate.trim() === '') {
      wx.showToast({
        title: '请选择起租日期',
        icon: 'none'
      });
      return false;
    }

    return true;
  },

  // 数字转中文大写
  numberToChinese(num) {
    const digits = ['零', '一', '二', '三', '四', '五', '六', '七', '八', '九'];
    const units = ['', '十', '百', '千', '万'];
    
    if (num === 0) return '零';
    if (num < 10) return digits[num];
    
    let result = '';
    let unitIndex = 0;
    let numStr = num.toString();
    
    for (let i = numStr.length - 1; i >= 0; i--) {
      const digit = parseInt(numStr[i]);
      if (digit !== 0) {
        result = digits[digit] + units[unitIndex] + result;
      } else if (result && result[0] !== '零') {
        result = digits[0] + result;
      }
      unitIndex++;
    }
    
    return result;
  },

  // 金额转大写（简化版，适用于万元以内）
  amountToChinese(amount) {
    const digits = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'];
    const units = ['', '拾', '佰', '仟'];
    
    if (!amount || amount === 0) return '零元整';
    
    const num = Math.floor(amount);
    if (num === 0) return '零元整';
    
    let result = '';
    let numStr = num.toString();
    const len = numStr.length;
    
    // 处理每一位数字
    for (let i = 0; i < len; i++) {
      const digit = parseInt(numStr[i]);
      const pos = len - i - 1;
      
      if (digit !== 0) {
        // 如果前面有零且当前不是最高位，添加零
        if (i > 0 && numStr[i - 1] === '0' && result && result[result.length - 1] !== '零') {
          result += '零';
        }
        result += digits[digit];
        if (pos > 0 && pos < 4) {
          result += units[pos];
        }
      }
    }
    
    return result + '元整';
  },

  // 解析户型（从房间信息中获取）
  parseHouseType(roomInfo) {
    if (!roomInfo) {
      return { roomType: '' };
    }
    return {
      roomType: roomInfo.roomType || ''
    };
  },

  // 解析日期
  parseDate(dateStr) {
    if (!dateStr) return { year: '', month: '', day: '' };
    const date = new Date(dateStr);
    return {
      year: date.getFullYear().toString(),
      month: (date.getMonth() + 1).toString(),
      day: date.getDate().toString()
    };
  },

  // 提交表单
  async onSubmit() {
    if (!this.validateForm()) {
      return;
    }

    const { name, phone, startDate, selectedRoomId, selectedRoom, monthlyRent, paymentMethod, deposit, endDate, flow, contractId } = this.data;
    
    // 如果是租客流程，先保存到云函数
    if (flow === 'tenant' && contractId) {
      wx.showLoading({
        title: '保存中...',
        mask: true
      });
      
      try {
        // 解析日期
        const startDateInfo = startDate ? this.parseDate(startDate) : { year: '', month: '', day: '' };
        const endDateInfo = endDate ? this.parseDate(endDate) : { year: '', month: '', day: '' };
        
        // 更新合同中的租客信息
        const res = await wx.cloud.callFunction({
          name: 'contract',
          data: {
            apiType: 'updateContractTenantDetails',
            contractId: contractId,
            tenantName: name,
            tenantPhone: phone,
            startYear: startDateInfo.year,
            startMonth: startDateInfo.month,
            startDay: startDateInfo.day,
            endYear: endDateInfo.year,
            endMonth: endDateInfo.month,
            endDay: endDateInfo.day,
            monthlyRent: monthlyRent,
            paymentMethod: paymentMethod,
            deposit: deposit
          }
        });
        
        wx.hideLoading();
        
        if (res.result.res.code === 200) {
          wx.showToast({
            title: '保存成功',
            icon: 'success'
          });
          
          // 跳转到合同页面
          setTimeout(() => {
            wx.navigateTo({
              url: `/pages/contract/index?contractId=${contractId}&flow=tenant`
            });
          }, 500);
        } else {
          wx.showToast({
            title: res.result.res.msg || '保存失败',
            icon: 'none'
          });
        }
        return;
      } catch (error) {
        console.error('保存合同失败:', error);
        wx.hideLoading();
        wx.showToast({
          title: '保存失败，请重试',
          icon: 'none'
        });
        return;
      }
    }
    
    // 房东流程，继续原有逻辑
    
    // 解析户型（从房间信息中获取）
    const houseTypeInfo = this.parseHouseType(selectedRoom);
    
    // 解析起租日期（如果有）
    const startDateInfo = startDate ? this.parseDate(startDate) : { year: '', month: '', day: '' };
    
    // 解析退租日期（如果有）
    const endDateInfo = endDate ? this.parseDate(endDate) : { year: '', month: '', day: '' };
    
    // 转换金额为大写
    const monthlyRentNum = parseFloat(monthlyRent);
    const depositNum = parseFloat(deposit);
    
    // 准备传递给合同页面的数据
    const contractData = {
      // 房间ID（用于云函数创建合同时关联房间）
      roomId: selectedRoomId,
      
      // 甲方（房东）信息
      landlordName: this.data.landlordInfo ? this.data.landlordInfo.name : '未填写',
      landlordPhone: this.data.landlordInfo ? this.data.landlordInfo.phone : '未填写',
      landlordIdCard: this.data.landlordInfo ? this.data.landlordInfo.idCard : '未填写',
      landlordAddress: this.data.landlordInfo ? this.data.landlordInfo.address : '未填写',
      
      // 乙方（承租人）信息（可选，租客后续可填写）
      tenantName: name || '',
      tenantPhone: phone || '',
      tenantIdCard: '', // 租客身份证号，签约时填写
      tenantAddress: '', // 租客地址，签约时填写
      
      // 房屋信息（从房间信息中获取）
      room: selectedRoom ? selectedRoom.room : '',
      area: selectedRoom ? selectedRoom.area : '',
      roomType: houseTypeInfo.roomType,
      
      // 地址信息（从房间信息中获取，如果没有则使用默认值）
      province: selectedRoom ? (selectedRoom.province || '四川省') : '四川省',
      city: selectedRoom ? (selectedRoom.city || '成都市') : '成都市',
      district: selectedRoom ? (selectedRoom.district || '新都区') : '新都区',
      street: selectedRoom ? (selectedRoom.street || '斑竹园街道') : '斑竹园街道',
      address: selectedRoom ? (selectedRoom.address || '鸿发路488号1栋17层') : '鸿发路488号1栋17层',
      
      // 租赁期限（可选，租客后续可填写）
      startYear: startDateInfo.year || '',
      startMonth: startDateInfo.month || '',
      startDay: startDateInfo.day || '',
      endYear: endDateInfo.year || '',
      endMonth: endDateInfo.month || '',
      endDay: endDateInfo.day || '',
      
      // 租金信息
      monthlyRent: monthlyRent,
      monthlyRentUpper: this.amountToChinese(monthlyRentNum),
      paymentMethod: paymentMethod,
      
      // 押金信息
      deposit: deposit,
      depositUpper: this.amountToChinese(depositNum),
      
      // 物业费（从房间信息中获取）
      propertyFee: selectedRoom ? (selectedRoom.propertyFee || '') : '',
      
      // 其他固定信息
      renewNoticeMonths: '1',
      paymentDaysBefore: '3',
      lateFeePercent: '5',
      deliveryYear: startDateInfo.year || '',
      deliveryMonth: startDateInfo.month || '',
      deliveryDay: startDateInfo.day || '',
      overdueDays: '15',
      overdueAmount: '1000',
      penaltyAmount: '2000',
      penaltyAmountUpper: this.amountToChinese(2000)
    };

    // 跳转到合同页面，传递数据和流程类型
    const currentFlow = this.data.flow || 'landlord';
    wx.navigateTo({
      url: '/pages/contract/index?data=' + encodeURIComponent(JSON.stringify(contractData)) + '&flow=' + currentFlow
    });
  }
});

